﻿using System.Collections.Generic;
using Microsoft.Practices.EnterpriseLibrary.Data;
using System.Data.Common;
using System.Data;
using System;
using log4net;
using PES.Common.Extensions;


namespace PES.Common.DAL
{
    using Model;

    internal class PartidaDAL
    {
        private static ILog s_logger;

        private static ILog Logger
        {
            get { return s_logger ?? (s_logger = LogManager.GetLogger("PartidaDAL")); }
        }

        public void CadastrarPartida(int _campeonatoID, Partida _partida)
        {
            Database db = DatabaseFactory.CreateDatabase(DbHelper.PES_DATABASE);

            string sql =
                "INSERT INTO Partida (data_partida, jogador1_id, jogador2_id, rodada, placar_registrado) VALUES ({0}, {1}, {2}, {3}, {4})";

            string dataPartidaParam = db.BuildParameterName("DataPartida");
            string jogador1Param = db.BuildParameterName("Jogador1");
            string jogador2Param = db.BuildParameterName("Jogador2");
            string rodadaParam = db.BuildParameterName("RodadaID");
            string placarRegParam = db.BuildParameterName("PlacReg");

            sql = string.Format(sql, dataPartidaParam, jogador1Param, jogador2Param, rodadaParam, placarRegParam);

            DbCommand cmd = db.GetSqlStringCommand(sql);
            db.AddInParameter(cmd, dataPartidaParam, DbType.DateTime, _partida.Data.Date);
            db.AddInParameter(cmd, jogador1Param, DbType.Int64, _partida.Jogador1.ID);
            db.AddInParameter(cmd, jogador2Param, DbType.Int64, _partida.Jogador2.ID);
            db.AddInParameter(cmd, rodadaParam, DbType.Int32, _partida.Rodada);
            db.AddInParameter(cmd, placarRegParam, DbType.Boolean, false);

            using (DbConnection connection = db.CreateConnection())
            {
                connection.Open();
                DbTransaction transaction = connection.BeginTransaction();
                try
                {
                    db.ExecuteNonQuery(cmd, transaction);
                    sql = "SELECT @@IDENTITY Partida";
                    cmd = db.GetSqlStringCommand(sql);
                    _partida.ID = Convert.ToInt64(db.ExecuteScalar(cmd, transaction));

                    sql = "INSERT INTO Campeonato_Partidas (campeonato_id, partida_id) VALUES ({0}, {1})";

                    string campIDParam = db.BuildParameterName("CampID");
                    string jogadorIDParam = db.BuildParameterName("JogID");

                    sql = string.Format(sql, campIDParam, _partida.ID);

                    cmd = db.GetSqlStringCommand(sql);
                    db.AddInParameter(cmd, campIDParam, DbType.Int32, _campeonatoID);
                    db.AddInParameter(cmd, jogadorIDParam, DbType.Int64, _partida.ID);

                    db.ExecuteNonQuery(cmd, transaction);

                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    Logger.Error("Ocorreu um erro ao salvar jogador.", ex);
                    transaction.Rollback();
                    throw;
                }
                finally
                {
                    connection.Close();
                }
            }

        }

        public IList<Partida> BuscarPartidasPorRodada(int _campeonatoID, int _rodada)
        {
            Database db = DatabaseFactory.CreateDatabase(DbHelper.PES_DATABASE);
            string sql = @"SELECT 
								P.partida_id,
								P.data_partida,
								P.jogador1_id,
								J1.nome,
								J1.time_escolhido,
								J1.pontuacao_id,
								P.jogador2_id,
								J2.nome,
								J2.time_escolhido,
								J2.pontuacao_id,
								P.rodada,
								P.gols_jogador1,
								P.gols_jogador2,
								P.placar_registrado,
								C.campeonato_id,
								C.nome
							FROM
								Partida P,
								Campeonato_Partidas CP,
								Campeonato C,
								Jogador J1,
								Jogador J2
							WHERE
								P.partida_id = CP.partida_id AND
								P.rodada = {1} AND
								C.campeonato_id = CP.campeonato_id AND
								J1.jogador_id = P.jogador1_id AND
								J2.jogador_id = P.jogador2_id AND
								C.campeonato_id = {0}";

            string campIDParam = db.BuildParameterName("CampID");
            string rodadaParam = db.BuildParameterName("RodadaID");

            sql = string.Format(sql, campIDParam, rodadaParam);

            DbCommand cmd = db.GetSqlStringCommand(sql);

            db.AddInParameter(cmd, campIDParam, DbType.Int32, _campeonatoID);
            db.AddInParameter(cmd, rodadaParam, DbType.Int32, _rodada);

            var lstPartidas = new List<Partida>();

            using (IDataReader dbReader = db.ExecuteReader(cmd))
            {
                while (dbReader.Read())
                {
                    var p = new Partida
                                {
                                    ID = dbReader.GetInt64(0),
                                    Data = dbReader.GetDateTime(1),
                                    Jogador1 =
                                        new Jogador
                                            {
                                                ID = dbReader.GetInt64(2),
                                                Nome = dbReader.GetString(3),
                                                TimeEscolhido = dbReader.GetString(4)
                                            }
                                };

                    if (!dbReader.IsDBNull(5))
                    {
                        p.Jogador1.Pontos = new Pontuacao {ID = dbReader.GetInt64(5)};
                    }

                    p.Jogador2 = new Jogador
                                     {
                                         ID = dbReader.GetInt64(6),
                                         Nome = dbReader.GetString(7),
                                         TimeEscolhido = dbReader.GetString(8)
                                     };

                    if (!dbReader.IsDBNull(9))
                    {
                        p.Jogador1.Pontos = new Pontuacao {ID = dbReader.GetInt64(9)};
                    }

                    p.Rodada = dbReader.GetInt32(10);

                    if (!dbReader.IsDBNull(11))
                    {
                        p.GolsJogador1 = dbReader.GetInt32(11);
                        p.GolsJogador2 = dbReader.GetInt32(12);
                    }

                    p.PlacarRegistrado = dbReader.GetBoolean(13);

                    p.Campeonato = new Campeonato {ID = dbReader.GetInt32(14), Nome = dbReader.GetString(15)};

                    lstPartidas.Add(p);
                }
            }

            return lstPartidas;
        }

        internal bool ValidaPartida(int _campeonatoID, Partida _partida, out int _rodada)
        {
            Database db = DatabaseFactory.CreateDatabase(DbHelper.PES_DATABASE);

            string sql = @"SELECT P.rodada 
							FROM 
								Partida P, Campeonato_Partidas CP   
							WHERE 
								P.jogador1_id = {0} AND
								P.jogador2_id = {1} AND
								P.partida_id = CP.partida_id AND
								CP.campeonato_id = {2}";

            string jog1Param = db.BuildParameterName("Jog1");
            string jog2Param = db.BuildParameterName("Jog2");
            string campIDParam = db.BuildParameterName("CampID");

            sql = string.Format(sql, jog1Param, jog2Param, campIDParam);

            DbCommand cmd = db.GetSqlStringCommand(sql);
            db.AddInParameter(cmd, jog1Param, DbType.Int64, _partida.Jogador1.ID);
            db.AddInParameter(cmd, jog2Param, DbType.Int64, _partida.Jogador2.ID);
            db.AddInParameter(cmd, campIDParam, DbType.Int32, _campeonatoID);

            object rodadaObj = db.ExecuteScalar(cmd);

            if (rodadaObj == null)
            {
                _rodada = 0;
                return true;
            }

            _rodada = Convert.ToInt32(rodadaObj);
            return false;
        }

        internal IList<Partida> BuscarPartidasPorData(int _campeonatoID, DateTime _data)
        {
            Database db = DatabaseFactory.CreateDatabase(DbHelper.PES_DATABASE);
            string sql = @"SELECT 
								P.partida_id,
								P.data_partida,
								P.jogador1_id,
								J1.nome,
								J1.time_escolhido,
								J1.pontuacao_id,
								P.jogador2_id,
								J2.nome,
								J2.time_escolhido,
								J2.pontuacao_id,
								P.rodada,
								P.gols_jogador1,
								P.gols_jogador2,
								P.placar_registrado,
								C.campeonato_id,
								C.nome
							FROM
								Partida P,
								Campeonato C,
								Campeonato_Partidas CP,
								Jogador J1,
								Jogador J2
							WHERE
								P.partida_id = CP.partida_id AND
								P.data_partida = {1} AND
								CP.campeonato_id = C.campeonato_id AND
								J1.jogador_id = P.jogador1_id AND
								J2.jogador_id = P.jogador2_id AND
								C.campeonato_id = {0}";

            string campIDParam = db.BuildParameterName("CampID");
            string dataPartParam = db.BuildParameterName("DataPart");

            sql = string.Format(sql, campIDParam, dataPartParam);

            DbCommand cmd = db.GetSqlStringCommand(sql);

            db.AddInParameter(cmd, campIDParam, DbType.Int32, _campeonatoID);
            db.AddInParameter(cmd, dataPartParam, DbType.DateTime, _data.Date);

            var lstPartidas = new List<Partida>();

            using (IDataReader dbReader = db.ExecuteReader(cmd))
            {
                while (dbReader.Read())
                {
                    var p = new Partida
                                {
                                    ID = dbReader.GetInt64(0),
                                    Data = dbReader.GetDateTime(1),
                                    Jogador1 =
                                        new Jogador
                                            {
                                                ID = dbReader.GetInt64(2),
                                                Nome = dbReader.GetString(3),
                                                TimeEscolhido = dbReader.GetString(4)
                                            }
                                };

                    if (!dbReader.IsDBNull(5))
                    {
                        p.Jogador1.Pontos = new Pontuacao {ID = dbReader.GetInt64(5)};
                    }

                    p.Jogador2 = new Jogador
                                     {
                                         ID = dbReader.GetInt64(6),
                                         Nome = dbReader.GetString(7),
                                         TimeEscolhido = dbReader.GetString(8)
                                     };

                    if (!dbReader.IsDBNull(9))
                    {
                        p.Jogador2.Pontos = new Pontuacao {ID = dbReader.GetInt64(9)};
                    }

                    p.Rodada = dbReader.GetInt32(10);

                    if (!dbReader.IsDBNull(11))
                    {
                        p.GolsJogador1 = dbReader.GetInt32(11);
                        p.GolsJogador2 = dbReader.GetInt32(12);
                    }

                    p.PlacarRegistrado = dbReader.GetBoolean(13);

                    p.Campeonato = new Campeonato {ID = dbReader.GetInt32(14), Nome = dbReader.GetString(15)};

                    lstPartidas.Add(p);
                }
            }

            return lstPartidas;
        }

        internal void AtualizaPartida(Partida _partida)
        {
            Database db = DatabaseFactory.CreateDatabase(DbHelper.PES_DATABASE);

            string sql =
                "UPDATE Partida SET data_partida = {0}, gols_jogador1 = {1}, gols_jogador2 = {2}, placar_registrado = {4} WHERE partida_id = {3}";

            string dataParam = db.BuildParameterName("DataPart");
            string golsJog1Param = db.BuildParameterName("GolsJog1");
            string golsJog2Param = db.BuildParameterName("GolsJog2");
            string partidaIDParam = db.BuildParameterName("PartidaID");
            string placarRegParam = db.BuildParameterName("PlacarReg");

            sql = string.Format(sql, dataParam, golsJog1Param, golsJog2Param, partidaIDParam, placarRegParam);

            DbCommand cmd = db.GetSqlStringCommand(sql);

            db.AddInParameter(cmd, dataParam, DbType.DateTime, _partida.Data.Date);
            db.AddInParameter(cmd, golsJog1Param, DbType.Int32, _partida.GolsJogador1);
            db.AddInParameter(cmd, golsJog2Param, DbType.Int32, _partida.GolsJogador2);
            db.AddInParameter(cmd, partidaIDParam, DbType.Int32, _partida.ID);
            db.AddInParameter(cmd, placarRegParam, DbType.Boolean, _partida.PlacarRegistrado);

            db.ExecuteNonQuery(cmd);
        }

        internal IList<Partida> BuscarPartidasPorJogador(int _campeonatoID, long _jogadorID)
        {
            Database db = DatabaseFactory.CreateDatabase(DbHelper.PES_DATABASE);
            string sql = @"SELECT 
								P.partida_id,
								P.data_partida,
								P.jogador1_id,
								J1.nome,
								J1.time_escolhido,
								J1.pontuacao_id,
								P.jogador2_id,
								J2.nome,
								J2.time_escolhido,
								J2.pontuacao_id,
								P.rodada,
								P.gols_jogador1,
								P.gols_jogador2,
								P.placar_registrado,
								C.campeonato_id,
								C.nome
							FROM
								Partida P,
								Campeonato C,
								Campeonato_Partidas CP,
								Jogador J1,
								Jogador J2
							WHERE
								P.partida_id = CP.partida_id AND                                
								CP.campeonato_id = C.campeonato_id AND
								C.campeonato_id = {0} AND
								J1.jogador_id = P.jogador1_id AND
								J2.jogador_id = P.jogador2_id AND
								(P.jogador1_id = {1} OR P.jogador2_id = {1})

							ORDER BY P.rodada";

            string campIDParam = db.BuildParameterName("CampID");
            string jogIDParam = db.BuildParameterName("JogID");

            sql = string.Format(sql, campIDParam, jogIDParam);

            DbCommand cmd = db.GetSqlStringCommand(sql);

            db.AddInParameter(cmd, campIDParam, DbType.Int32, _campeonatoID);
            db.AddInParameter(cmd, jogIDParam, DbType.Int64, _jogadorID);

            var lstPartidas = new List<Partida>();

            using (IDataReader dbReader = db.ExecuteReader(cmd))
            {
                while (dbReader.Read())
                {
                    var p = new Partida
                                {
                                    ID = dbReader.GetInt64(0),
                                    Data = dbReader.GetDateTime(1),
                                    Jogador1 =
                                        new Jogador
                                            {
                                                ID = dbReader.GetInt64(2),
                                                Nome = dbReader.GetString(3),
                                                TimeEscolhido = dbReader.GetString(4)
                                            }
                                };

                    if (!dbReader.IsDBNull(5))
                    {
                        p.Jogador1.Pontos = new Pontuacao {ID = dbReader.GetInt64(5)};
                    }

                    p.Jogador2 = new Jogador
                                     {
                                         ID = dbReader.GetInt64(6),
                                         Nome = dbReader.GetString(7),
                                         TimeEscolhido = dbReader.GetString(8)
                                     };

                    if (!dbReader.IsDBNull(9))
                    {
                        p.Jogador1.Pontos = new Pontuacao {ID = dbReader.GetInt64(9)};
                    }

                    p.Rodada = dbReader.GetInt32(10);

                    if (!dbReader.IsDBNull(11))
                    {
                        p.GolsJogador1 = dbReader.GetInt32(11);
                        p.GolsJogador2 = dbReader.GetInt32(12);
                    }

                    p.PlacarRegistrado = dbReader.GetBoolean(13);

                    p.Campeonato = new Campeonato {ID = dbReader.GetInt32(14), Nome = dbReader.GetString(15)};

                    lstPartidas.Add(p);
                }
            }

            return lstPartidas;
        }

        internal Partida BuscarPartida(long _partidaID)
        {
            Database db = DatabaseFactory.CreateDatabase(DbHelper.PES_DATABASE);
            string sql = @"SELECT 
								P.partida_id,
								P.data_partida,
								P.jogador1_id,
								J1.nome,
								J1.time_escolhido,
								J1.pontuacao_id,
								P.jogador2_id,
								J2.nome,
								J2.time_escolhido,
								J2.pontuacao_id,
								P.rodada,
								P.gols_jogador1,
								P.gols_jogador2,
								P.placar_registrado,
								C.campeonato_id,
								C.nome
							FROM
								Partida P,
								Campeonato C,
								Campeonato_Partidas CP,
								Jogador J1,
								Jogador J2
							WHERE
								P.partida_id = {0} AND
								CP.partida_id = p.partida_id AND
								C.campeonato_id = CP.campeonato_id AND
								J1.jogador_id = P.jogador1_id AND
								J2.jogador_id = P.jogador2_id";

            string partidaIDParam = db.BuildParameterName("PartidaID");

            sql = string.Format(sql, partidaIDParam);

            DbCommand cmd = db.GetSqlStringCommand(sql);

            db.AddInParameter(cmd, partidaIDParam, DbType.Int64, _partidaID);

            Partida p = null;

            using (IDataReader dbReader = db.ExecuteReader(cmd))
            {
                if (dbReader.Read())
                {
                    p = new Partida
                            {
                                ID = dbReader.GetInt64(0),
                                Data = dbReader.GetDateTime(1),
                                Jogador1 =
                                    new Jogador
                                        {
                                            ID = dbReader.GetInt64(2),
                                            Nome = dbReader.GetString(3),
                                            TimeEscolhido = dbReader.GetString(4)
                                        }
                            };

                    if (!dbReader.IsDBNull(5))
                    {
                        p.Jogador1.Pontos = new Pontuacao {ID = dbReader.GetInt64(5)};
                    }

                    p.Jogador2 = new Jogador
                                     {
                                         ID = dbReader.GetInt64(6),
                                         Nome = dbReader.GetString(7),
                                         TimeEscolhido = dbReader.GetString(8)
                                     };

                    if (!dbReader.IsDBNull(9))
                    {
                        p.Jogador1.Pontos = new Pontuacao {ID = dbReader.GetInt64(9)};
                    }

                    p.Rodada = dbReader.GetInt32(10);

                    if (!dbReader.IsDBNull(11))
                    {
                        p.GolsJogador1 = dbReader.GetInt32(11);
                        p.GolsJogador2 = dbReader.GetInt32(12);
                    }

                    p.PlacarRegistrado = dbReader.GetBoolean(13);

                    p.Campeonato = new Campeonato {ID = dbReader.GetInt32(14), Nome = dbReader.GetString(15)};
                }
            }

            return p;
        }

        internal bool AcabouPontosCorridos(int _campeonatoID)
        {
            Database db = DatabaseFactory.CreateDatabase(DbHelper.PES_DATABASE);
            string sql = @"SELECT 
								COUNT(*)
							FROM
								Partida P, 
								Campeonato_Partidas CP,
								Campeonato C
							WHERE 
								C.campeonato_id = CP.campeonato_id AND
								P.partida_id = CP.partida_id AND
								CP.campeonato_id = {0} AND
								P.rodada <= C.qtde_rodadas AND
								(P.gols_jogador1 is null OR
								 P.gols_jogador2 is null)";

            string campIDParam = db.BuildParameterName("CampID");

            sql = string.Format(sql, campIDParam);

            DbCommand cmd = db.GetSqlStringCommand(sql);

            db.AddInParameter(cmd, campIDParam, DbType.Int64, _campeonatoID);

            object objRetorno = db.ExecuteScalar(cmd);

            return objRetorno != null && int.Parse(objRetorno.ToString()) == 0;
        }

        internal IList<Partida> BuscaConfrontosAnteriores(long _jogador1ID, long _jogador2ID, int _rodadaAtual)
        {
            Database db = DatabaseFactory.CreateDatabase(DbHelper.PES_DATABASE);
            const string sql = @"SELECT 
								P.partida_id,
								P.data_partida,
								P.jogador1_id,
								J1.nome,
								J1.time_escolhido,
								J1.pontuacao_id,
								P.jogador2_id,
								J2.nome,
								J2.time_escolhido,
								J2.pontuacao_id,
								P.rodada,
								P.gols_jogador1,
								P.gols_jogador2,
								P.placar_registrado,
								C.campeonato_id,
								C.nome
							FROM
								Partida P,
								Campeonato C,
								Campeonato_Partidas CP,
								Jogador J1,
								Jogador J2
							WHERE								
								CP.partida_id = p.partida_id AND
								C.campeonato_id = CP.campeonato_id AND								
								(J1.jogador_id = {0} OR J1.jogador_id = {1}) AND
								(J2.jogador_id = {1} OR J2.jogador_id = {0}) AND
                                P.jogador1_id = J1.jogador_id AND
                                P.jogador2_id = J2.jogador_id AND
                                P.rodada <> {2} AND
                                P.gols_jogador1 IS NOT NULL
                                ORDER BY C.campeonato_id ASC, P.Rodada ASC";

            DbCommand cmd = db.CreateCommand(sql, DbParam.Create(_jogador2ID), DbParam.Create(_jogador1ID),
                                             DbParam.Create(_rodadaAtual));

            var partidasAnteriores = new List<Partida>();

            using (IDataReader dbReader = db.ExecuteReader(cmd))
            {
                while (dbReader.Read())
                {
                    var p = new Partida
                                {
                                    ID = dbReader.GetValue<long>(0),
                                    Data = dbReader.GetValue<DateTime>(1),
                                    Jogador1 =
                                        new Jogador
                                            {
                                                ID = dbReader.GetValue<long>(2),
                                                Nome = dbReader.GetValue<string>(3),
                                                TimeEscolhido = dbReader.GetValue<string>(4)
                                            }
                                };

                    if (!dbReader.IsDBNull(5))
                    {
                        p.Jogador1.Pontos = new Pontuacao {ID = dbReader.GetValue<long>(5)};
                    }

                    p.Jogador2 = new Jogador
                                     {
                                         ID = dbReader.GetValue<long>(6),
                                         Nome = dbReader.GetValue<string>(7),
                                         TimeEscolhido = dbReader.GetValue<string>(8)
                                     };

                    if (!dbReader.IsDBNull(9))
                    {
                        p.Jogador1.Pontos = new Pontuacao {ID = dbReader.GetValue<long>(9)};
                    }

                    p.Rodada = dbReader.GetValue<int>(10);

                    if (!dbReader.IsDBNull(11))
                    {
                        p.GolsJogador1 = dbReader.GetValue<int>(11);
                        p.GolsJogador2 = dbReader.GetValue<int>(12);
                    }

                    p.PlacarRegistrado = dbReader.GetValue<bool>(13);

                    p.Campeonato = new Campeonato
                                       {ID = dbReader.GetValue<int>(14), Nome = dbReader.GetValue<string>(15)};

                    partidasAnteriores.Add(p);
                }
            }

            return partidasAnteriores;
        }

        internal IList<Partida> BuscarTodasPartidas(int _campeonatoID)
        {
            Database db = DatabaseFactory.CreateDatabase(DbHelper.PES_DATABASE);
            const string sql = @"SELECT 
								P.partida_id,
								P.data_partida,
								P.jogador1_id,
								J1.nome,
								J1.time_escolhido,
								J1.pontuacao_id,
								P.jogador2_id,
								J2.nome,
								J2.time_escolhido,
								J2.pontuacao_id,
								P.rodada,
								P.gols_jogador1,
								P.gols_jogador2,
								P.placar_registrado,
								C.campeonato_id,
								C.nome
							FROM
								Partida P,
								Campeonato C,
								Campeonato_Partidas CP,
                                Jogador J1,
								Jogador J2
							WHERE
								P.partida_id = CP.partida_id AND                                
								CP.campeonato_id = C.campeonato_id AND
                                P.jogador1_id = J1.jogador_id AND
                                P.jogador2_id = J2.jogador_id AND
								C.campeonato_id = {0}
								
							ORDER BY P.rodada";

            DbCommand cmd = db.CreateCommand(sql, DbParam.Create(_campeonatoID));

            var lstPartidas = new List<Partida>();

            using (IDataReader dbReader = db.ExecuteReader(cmd))
            {
                while (dbReader.Read())
                {
                    var p = new Partida
                                {
                                    ID = dbReader.GetValue<long>(0),
                                    Data = dbReader.GetValue<DateTime>(1),
                                    Jogador1 =
                                        new Jogador
                                            {
                                                ID = dbReader.GetValue<long>(2),
                                                Nome = dbReader.GetValue<string>(3),
                                                TimeEscolhido = dbReader.GetValue<string>(4)
                                            }
                                };

                    if (!dbReader.IsDBNull(5))
                    {
                        p.Jogador1.Pontos = new Pontuacao {ID = dbReader.GetValue<long>(5)};
                    }

                    p.Jogador2 = new Jogador
                                     {
                                         ID = dbReader.GetValue<long>(6),
                                         Nome = dbReader.GetValue<string>(7),
                                         TimeEscolhido = dbReader.GetValue<string>(8)
                                     };

                    if (!dbReader.IsDBNull(9))
                    {
                        p.Jogador1.Pontos = new Pontuacao {ID = dbReader.GetValue<long>(9)};
                    }

                    p.Rodada = dbReader.GetInt32(10);

                    if (!dbReader.IsDBNull(11))
                    {
                        p.GolsJogador1 = dbReader.GetValue<int>(11);
                        p.GolsJogador2 = dbReader.GetValue<int>(12);
                    }

                    p.PlacarRegistrado = dbReader.GetValue<bool>(13);

                    p.Campeonato = new Campeonato
                                       {ID = dbReader.GetValue<int>(14), Nome = dbReader.GetValue<string>(15)};

                    lstPartidas.Add(p);
                }
            }

            return lstPartidas;
        }

        internal void RegistraAcaoPartida(long _partidaID, TipoAcaoPartida _acaoPartida, string _textoAcao)
        {
            Database db = DatabaseFactory.CreateDatabase(DbHelper.PES_DATABASE);
            const string sql =
                "INSERT INTO Acao_Partida (partida_id, datahora_acao, tipo_acao, texto_acao) VALUES ({0}, {1}, {2}, {3})";

            DbCommand cmd = db.CreateCommand(sql, DbParam.Create(_partidaID), DbParam.Create(DateTime.Now),
                                             DbParam.Create((short) _acaoPartida), DbParam.Create(_textoAcao));

            db.ExecuteNonQuery(cmd);
        }

        internal IEnumerable<AcaoPartida> BuscaAcoesPartida(long _partidaID)
        {
            Database db = DatabaseFactory.CreateDatabase(DbHelper.PES_DATABASE);
            const string sql =
                @"SELECT AP.datahora_acao, AP.tipo_acao, AP.texto_acao
                  FROM
                        Acao_Partida AP
                  WHERE
                        AP.partida_id = {0}
                  ORDER BY AP.datahora_acao DESC";

            DbCommand cmd = db.CreateCommand(sql, DbParam.Create(_partidaID));

            var acoesPartida = new List<AcaoPartida>();

            using (IDataReader dbReader = db.ExecuteReader(cmd))
            {
                while (dbReader.Read())
                {
                    var acaoPartida = new AcaoPartida
                                          {
                                              AcaoRealizada = (TipoAcaoPartida) dbReader.GetValue<short>(1),
                                              DataHoraAcao = dbReader.GetValue<DateTime>(0),
                                              Partida = new Partida {ID = _partidaID},
                                              Texto = dbReader.GetValue<string>(2)
                                          };
                    acoesPartida.Add(acaoPartida);
                }
            }

            return acoesPartida;
        }
    }
}